package com.isd.pool.web;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import com.isd.facturacion.modelo.ItemMovimientoTiendaPK;
import com.isd.facturacion.modelo.ItemProductoTienda;
import com.isd.facturacion.modelo.MovimientoTienda;
import com.isd.facturacion.rn.MovimientoFacturacionRN;
import com.isd.global.excepciones.ExcepcionGeneralSistema;
import com.isd.global.excepciones.RollbackFailureException;
import com.isd.global.modelo.CorreoElectronico;
import com.isd.global.modelo.Parametro;
import com.isd.global.rn.MonedaRN;
import com.isd.global.rn.ParametrosRN;
import com.isd.global.util.JsfUtil;
import com.isd.global.util.SenderEmail;
import com.isd.global.web.MailFactory;
import com.isd.inventario.modelo.Producto;
import com.isd.inventario.web.BuscadorProductoBean;
import com.isd.pool.modelo.BasesCondicionesAdicionales;
import com.isd.pool.modelo.CondicionesPagoPool;
import com.isd.pool.modelo.EstadoPool;
import com.isd.pool.modelo.EstadoReserva;
import com.isd.pool.modelo.ItemProductoPool;
import com.isd.pool.modelo.ItemReserva;
import com.isd.pool.modelo.Pool;
import com.isd.pool.modelo.PoolTipo;
import com.isd.pool.modelo.ReservasPool;
import com.isd.pool.rn.PoolRN;
import com.isd.pool.rn.PoolTipoRN;
import com.isd.seguridad.web.UsuarioSessionBean;
import com.isd.venta.modelo.CondicionDePago;
import com.isd.ventas.rn.CondicionDePagoRN;
import java.io.Serializable;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;


/**
 * Beans para administrar los pooles desde el panel de administración de usuarios
 * @author ctrosch
 */
@ManagedBean
@ViewScoped
public class PoolBean implements Serializable{


    @EJB private ParametrosRN parametroRN;
    @EJB private PoolRN poolRN;
    @EJB private MovimientoFacturacionRN movimientoFacturacionRN;
    @EJB private MonedaRN monedaRN;
    @EJB private CondicionDePagoRN condicionDePagoRN;
    @EJB private PoolTipoRN poolTipoRN;

    private List<Pool> lista;
    private List<PoolTipo> tipos;
    private Pool pool;

    private ItemProductoPool itemProducto;    
    private CondicionesPagoPool itemCondicionPago;
    private BasesCondicionesAdicionales itemBasesCondicionesAdicionales;

    private List<CondicionDePago> listaCondicionesDePago;

    private Parametro p;
    private boolean nuevo;

    @ManagedProperty(value = "#{usuarioSessionBean}")
    private UsuarioSessionBean usuarioSession;

    @ManagedProperty(value = "#{buscadorProductoBean}")
    protected BuscadorProductoBean buscadorProductoBean;

    @ManagedProperty(value = "#{poolAplicacionBean}")
    private PoolAplicacionBean poolAplicacionBean;

    
    @EJB private MailFactory mailFactoryBean;

    /** Creates a new instance of PoolBean */
    public PoolBean() {

    }

    @PostConstruct
    public void init() {

        try {
            
            listaCondicionesDePago = condicionDePagoRN.getCondicionesDePago(null);            
            tipos = poolTipoRN.getLista();
            lista = poolRN.getLista();
            pool = new Pool();
            nuevo = false;
            p = parametroRN.getParametros();
            
        } catch (Exception ex) {

        }
    }

    public void guardar(boolean nuevo){

        try {
            if(!validarDatos()) return;

            poolRN.guardar(pool);
            lista = poolRN.getLista();            
            poolAplicacionBean.actualizarDatos();
            JsfUtil.addInfoMessage("Los datos se actualizaron corectamente");
            nuevo = false;

            if(nuevo){
                nuevo();
            }

        } catch (Exception e) {
            e.printStackTrace();
            JsfUtil.addErrorMessage("No es posible guardar los datos");
        }
    }

    public void nuevo(){

        Integer proxNroPool = poolRN.getNumeroMaximoPool();
        
        pool = new Pool(proxNroPool + 1);        
        itemProducto = new ItemProductoPool();
        itemCondicionPago = new CondicionesPagoPool();
        itemBasesCondicionesAdicionales = new BasesCondicionesAdicionales();
        
        asignarCodigoAceso();
        
        nuevo = true;
    }

    public boolean getPuedoModificar(){

        if(pool==null) return false;

        if(pool.getEstado().equals(EstadoPool.NoActivo)
          ||pool.getEstado().equals(EstadoPool.Activo)
          ||pool.getEstado().equals(EstadoPool.NoCerrado)
          ||pool.getEstado().equals("")){
            return true;
        }else{
            return false;
        }
    }

    public void seleccionar(Pool p){
        
        pool = p;
        itemProducto = new ItemProductoPool();
        itemCondicionPago = new CondicionesPagoPool();
        itemBasesCondicionesAdicionales = new BasesCondicionesAdicionales();
    }

    public boolean validarDatos(){

        boolean todoOk = true;

        if(pool.getDisponibleDesde().after(pool.getDisponibleHasta())){

            JsfUtil.addErrorMessage("La fecha disponible desde, no puede ser mayor a la fecah disponible hasta");
            todoOk = false;
        }
        
        if(pool.getCantidadDisponible().compareTo(pool.getCantidadTotal())==1 ){

            JsfUtil.addErrorMessage("Cantidad disponible mayor a cantidad total");
            todoOk = false;
        }
        
        if(pool.getDescripcion().isEmpty()){
            JsfUtil.addErrorMessage("La descripción no puede estar en blanco");
            todoOk = false;
        }
        
        if(pool.getPathImagenInicioCompra().isEmpty()){
            JsfUtil.addErrorMessage("La imagen de inicio del proceso de compra no puede estar en blanco no puede estar en blanco");
            todoOk = false;
        }
        
        if(pool.getPathImagenPoolFinalizado().isEmpty()){
            JsfUtil.addErrorMessage("La imagen de fin del proceso de compra no puede estar en blanco no puede estar en blanco");
            todoOk = false;
        }

        if(pool.getProductos().isEmpty()){
            JsfUtil.addErrorMessage("Ingrese al menos un producto a publicar en el pool");
            todoOk = false;
        }

        if(pool.getCondiconesDePago().isEmpty()){
            JsfUtil.addErrorMessage("Ingrese al menos una condición de pago a publicar en el pool");
            todoOk = false;
        }
        
        int cantProducto= 0;
        
        for(ItemProductoPool p : pool.getProductos()){
            
            cantProducto = cantProducto + p.getCantidadTotal().intValue();
        }
        
        if(!(cantProducto==pool.getCantidadTotal().intValue())){
            JsfUtil.addErrorMessage("La cantidad total ofrecida ("+pool.getCantidadTotal()+") no coincide con la suma de cantidades ofrecidas de los items ("+cantProducto+")");
            
            todoOk = false;
        }
        return todoOk;
    }

    public void actualizarCantidades(){

        try {
            pool.setCantidadDisponible(pool.getCantidadTotal());
        } catch (Exception e) {
            pool.setCantidadDisponible(BigDecimal.ZERO);
        }
    }

    public void activarPool(){

        if(pool.getEstado().equals(EstadoPool.Activo)){
            JsfUtil.addWarningMessage("La venta especial ya se encuentra activo");
            return;
        }

        if(!pool.getEstado().equals(EstadoPool.NoActivo)){
            JsfUtil.addWarningMessage("No es posible activar la operación nuevamente");
            return;
        }

        pool.setEstado(EstadoPool.Activo);
        guardar(false);
    }

    public void anularPool(){
        pool.setEstado(EstadoPool.Anulado);
        guardar(false);
    }

    public void reActivar(){
        pool.setEstado(EstadoPool.Activo);
        guardar(false);
    }

    public void deshabilitar(){

        pool.setDebaja("S");
        try {
            guardar(false);
            JsfUtil.addInfoMessage("La venta especial ha sido deshabilitada");
        } catch (Exception e) {
            JsfUtil.addErrorMessage("No es posible deshabilitar la venta especial");
        }
    }

    public void agregarProducto(){

        try {
            
            Producto prd = buscadorProductoBean.getProducto();
            
            if(prd.getTippro().isEmpty()){
                JsfUtil.addErrorMessage("Seleccione un producto"); 
                return;
            }
            
            if(itemProducto.getCantidadMinima()==null){                
                JsfUtil.addErrorMessage("Ingrese un valor mayor a cero para cantidad mínima"); 
                return;
            } 
            
            if(itemProducto.getCantidadMaxima()==null){                
                JsfUtil.addErrorMessage("Ingrese un valor mayor a cero para cantidad máxima"); 
                return;
            } 
            
            if(itemProducto.getCantidadMaxima().compareTo(itemProducto.getCantidadMinima())< 0){                
                JsfUtil.addErrorMessage("El valor máximo no puede ser menor al mínimo"); 
                return;
            } 
            
            if(itemProducto.getCantidadTotal().compareTo(BigDecimal.ZERO)<=0){                
                JsfUtil.addErrorMessage("Ingrese un valor mayor a cero para la cantidad total ofrecida");                
                return;
            }            

            itemProducto.setNroPool(pool.getNroPool());
            itemProducto.setOrden(pool.getProductos().size()+1);
            itemProducto.setCantidadDisponible(itemProducto.getCantidadTotal());

            itemProducto.setPool(pool);            
            itemProducto.setProducto(prd);

            pool.getProductos().add(itemProducto);

            itemProducto = new ItemProductoPool();

            buscadorProductoBean.reset();

            JsfUtil.addInfoMessage("El producto ha sido agregado");
            
        } catch (Exception ex) {
            ex.printStackTrace();
            JsfUtil.addErrorMessage("No es posible agregar el producto");
            JsfUtil.addErrorMessage(ex.getMessage());
        }
    }

    public void eliminarProducto(ItemProductoPool item){
        
        if(!pool.getEstado().equals(EstadoPool.NoActivo)){
            JsfUtil.addErrorMessage("No es posible eliminar el producto en el estado actual de la venta especial");
            return;
        }

        if(pool.getProductos().remove(item)){
            if(!nuevo){
                poolRN.eliminarItemProducto(item);
            }
            JsfUtil.addWarningMessage("El producto ha sido eliminado");
        }else{
            JsfUtil.addErrorMessage("No es posible eliminar el producto");
        }
    }

    public void agregarCondicionPago(){

        try {
            
            if(itemCondicionPago.getDescripcion()==null){
                JsfUtil.addErrorMessage("Ingrese la descripción para mostrar como");
                return;
            }
            
            if(itemCondicionPago.getPrecioNormal()==null){
                JsfUtil.addErrorMessage("Ingrese el precio normal");
                return;
            }
            
            if(itemCondicionPago.getPrecioPool()==null){
                JsfUtil.addErrorMessage("Ingrese el precio especial para la venta especial");
                return;
            }
            
            if(itemCondicionPago.getPrecioNormal().compareTo(itemCondicionPago.getPrecioPool())<=0){
                JsfUtil.addErrorMessage("El precio especial no puede ser igual o mayor al precio normal");
                return;
            }
            
            
            if(itemCondicionPago.getIvaProduto()==null){
                JsfUtil.addErrorMessage("Seleccione el IVA del producto");
                return;
            }            
            
            itemCondicionPago.setNroPool(pool.getNroPool());
            itemCondicionPago.setOrden(pool.getCondiconesDePago().size()+1);
            itemCondicionPago.setPool(pool);

            pool.getCondiconesDePago().add(itemCondicionPago);
            itemCondicionPago = new CondicionesPagoPool();
            
            JsfUtil.addInfoMessage("La condición de pago ha sido agregada");

        } catch (Exception ex) {
            
            JsfUtil.addErrorMessage("No es posible agregar la condición de pago");
            JsfUtil.addErrorMessage(ex.getMessage());
        }
    }

    public void eliminarCondicionPago(CondicionesPagoPool item){
        
        if(!pool.getEstado().equals(EstadoPool.NoActivo)&&!pool.getEstado().equals(EstadoPool.Activo)){
            JsfUtil.addErrorMessage("No es posible eliminar el producto en el estado actual de la venta especial");
            return;
        }

        if(pool.getCondiconesDePago().remove(item)){

            if(!nuevo){
                poolRN.eliminarCondicionPago(item);
            }
            JsfUtil.addWarningMessage("La condición de pago ha sido eliminada");

            
        }else{
            JsfUtil.addErrorMessage("No es posible eliminar la condición de pago");
        }
    }

    public void agregarBasesCondAdicional(){

        try {
            
            itemBasesCondicionesAdicionales.setNroPool(pool.getNroPool());
            itemBasesCondicionesAdicionales.setNroitm(pool.getBaseCondicionesAdicionales().size()+1);

            itemBasesCondicionesAdicionales.setPool(pool);
            pool.getBaseCondicionesAdicionales().add(itemBasesCondicionesAdicionales);

            itemBasesCondicionesAdicionales = new BasesCondicionesAdicionales();
            JsfUtil.addInfoMessage("El item fue agregado");

        } catch (Exception ex) {
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "agregarBasesCondAdicional", ex);
            JsfUtil.addErrorMessage("No es posible agregar el item");
            JsfUtil.addErrorMessage(ex.getMessage());
        }
    }

    public void eliminarBasesCondAdicional(BasesCondicionesAdicionales item){

        if(pool.getBaseCondicionesAdicionales()== null) return;

        if(pool.getBaseCondicionesAdicionales().remove(item)){
            if(!nuevo){
                poolRN.eliminarBaseCondicionesAdicionales(item);
            }
            JsfUtil.addWarningMessage("El item fue eliminado");
        }else{
            JsfUtil.addErrorMessage("No es posible eliminar el item");
        }
    }

    public void finalizarPool(){

        boolean existenErrores = false;

        try {
            pool = poolRN.getPool(pool.getNroPool());

            if (!pool.getEstado().equals(EstadoPool.Cerrado)) {
                JsfUtil.addErrorMessage("La venta especial no ha sido cerrada, no es posible generar pedidos");
                return;
            }                        
            poolAplicacionBean.sincronizarCantidades(pool); 
            pool = poolRN.getPool(pool.getNroPool());

            for (ReservasPool rs : pool.getReservas()) {

                try {
                    if (rs.getEstado().equals(EstadoReserva.Confirmado)) {

                        MovimientoTienda pedido = movimientoFacturacionRN.nuevoMovimiento(rs.getCliente(), "FC", "PRW", "0130");
                        
                        if(pedido!=null){                            
                            pedido.setCondicionDePago(rs.getCondicionDePago());
                            pedido.setTextos(rs.getTextos());
                            pedido.setNroPool(pool.getNroPool());
                            pedido.setEstaut((short) 1 );
                            pedido.setFchaut(new Date());
                        
                            for (ItemReserva ir : rs.getItemReservas()) {
                                agregoProductoPedido(pedido, ir);
                            }
                            rs.setPedido(pedido);                        
                            //Generamos items componentes si existen productos de tipo kit
                            movimientoFacturacionRN.generoItemsComponente(pedido);
                            movimientoFacturacionRN.guardar(pedido);
                            rs.setEstado(EstadoReserva.PedidoGenerado);                            
                        }else{
                            rs.setTextos("Pedido Nulo");
                            rs.setEstado(EstadoReserva.PedidoNoGenerado);                                                        
                        }
                    } 
                    
                } catch (ExcepcionGeneralSistema egs) {
                    
                    existenErrores = true;                    
                    rs.setEstado(EstadoReserva.PedidoNoGenerado); 
                    rs.setTextos(egs.getMessage());
                    pool.setErrores(pool.getErrores()+"\n"+rs.getCliente().getNrocta()+" - "+ rs.getOrden()+" Error: "+egs.getMessage());
                }
            }

            if(existenErrores){
                pool.setEstado(EstadoPool.FinalizadoFalla);
            }else{
                pool.setEstado(EstadoPool.FinalizadoExito);
            }              
            
            poolRN.guardar(pool);
            lista = poolRN.getLista();
            poolAplicacionBean.actualizarDatos();
            enviarNotificaciones();
            
        } catch (Exception e) {
            try {
                Logger.getLogger(getClass().getName()).log(Level.SEVERE, "finalizarPool", e);
                JsfUtil.addErrorMessage("Error al finalizar la venta especial ");
                pool.setEstado(EstadoPool.ErrorInesperado);
                pool.setErrores(pool.getErrores()+"\n Error: " + e.getMessage());
                poolRN.guardar(pool);
            } catch (RollbackFailureException ex) {
                Logger.getLogger(PoolBean.class.getName()).log(Level.SEVERE, null, ex);
            } catch (Exception ex) {
                Logger.getLogger(PoolBean.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    public void enviarNotificaciones(){
        
        if (!pool.getEstado().equals(EstadoPool.FinalizadoExito)) {
            JsfUtil.addErrorMessage("La venta especial no ha sido cerrada o no finalizó con éxito, no es posible generar pedidos");
            return;
        }    

        List<CorreoElectronico> correos = new ArrayList<CorreoElectronico>();

        for(ReservasPool rs:pool.getReservas()){

            if (rs.getEstado().equals(EstadoReserva.PedidoGenerado)) {
            
                String destinatario = "";

                if(p.getModoPrueba().equals("S")){

                    destinatario = p.getRecepcionNotificacionModoPrueba();  

                }else{

                    destinatario = (rs.getCliente().getDireml()==null?"":rs.getCliente().getDireml());
                }

                CorreoElectronico ce = new CorreoElectronico();

                if(!destinatario.isEmpty()){

                    ce.setAsunto(pool.getTipo().getDescrp() + " - Nro.: "+pool.getNroPool() + " Activado! - Pedido Nro. " + rs.getPedido().getId().getNrofor() + " ha sido confirmado");
                    ce.setDestinatarios(destinatario);
                    ce.setContenido(mailFactoryBean.generarMensaje("Ventas especiales",movimientoFacturacionRN.generarMensajeCorreoElectronico(rs.getPedido())));

                }else{
                    destinatario = "claudiotrosch@gmail.com";
                    ce = JsfUtil.getCorreoElectronicoClienteSinCorreo(rs.getCliente(), destinatario);                        
                }            
                correos.add(ce);
            }
        }

        CorreoElectronico ceEmp = generarCorreoResumenPoolEmpresa();
        correos.add(ceEmp);

        //Enviamos los correos con un nuevo hilo...
        SenderEmail se = new SenderEmail(mailFactoryBean, correos);
        se.start();
        
        JsfUtil.addInfoMessage("Los datos han sido actualizado");
    }

    public CorreoElectronico generarCorreoResumenPoolEmpresa(){
        
        String asunto = pool.getTipo().getDescrp() +  " - Nro.: " + pool.getNroPool() + " - " + pool.getDescripcion() + " Activado!";
        String destinatarios;
        
        try {
            
            destinatarios = parametroRN.getParametros().getCorreoElectronicoPool();
            
        } catch (Exception ex) {
            
            destinatarios = "claudiotrosch@gmail.com";
        }
        
        SimpleDateFormat formateadorFechaHora = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");

        List<String> contenido = new ArrayList<String>();

        contenido.add("<b>"+pool.getTipo().getDescrp()+" finalizado con éxito</b>");
        contenido.add("<hr/>");
        contenido.add("Nro: " + pool.getNroPool());
        contenido.add("Descripción: " + pool.getDescripcion());
        contenido.add("Disponible desde: " + formateadorFechaHora.format(pool.getDisponibleDesde()));
        contenido.add("Disponible hasta: " + formateadorFechaHora.format(pool.getDisponibleHasta()));
        contenido.add("Cantidad publicada:" + pool.getCantidadTotal().toBigInteger());

        contenido.add("<b>Pedidos generados</b>");
        contenido.add("<hr/>");

        for (ReservasPool rs : pool.getReservas()) {            
            if (rs.getEstado().equals(EstadoReserva.PedidoGenerado)) {
                   contenido.add(rs.getPedido().getId().getCodfor() + " - " + rs.getPedido().getId().getNrofor() + " - (" + rs.getCliente().getNrocta() + ") " + rs.getCliente().getNombre());                
            }            
        }

        CorreoElectronico cee = new CorreoElectronico(asunto, destinatarios, mailFactoryBean.generarMensaje("Ventas especiales",contenido));
        return cee;
    }

    public void agregoProductoPedido(MovimientoTienda m, ItemReserva ir){

        ItemProductoTienda item = new ItemProductoTienda();
        ItemMovimientoTiendaPK iPK = new ItemMovimientoTiendaPK(
                m.getId().getModfor(),
                m.getId().getCodfor(),
                m.getId().getNrofor(),
                m.getItemsProducto().size(),
                "1",
                m.getId().getModfor(),
                m.getId().getCodfor(),
                m.getId().getNrofor(),
                m.getItemsProducto().size(),
                "1");
        try {

            item.setItemMovimientoVentaPK(iPK);
            item.setCantid(ir.getCantidad());
            item.setProducto(ir.getProducto());

            item.setPrecio(ir.getPrecio());
            item.setPrenac(ir.getPrecio());
            item.setPresec(ir.getPrecio().divide(monedaRN.getCotizacionDia("USD"), 4 ,BigDecimal.ROUND_FLOOR));

            item.setPctbf1(BigDecimal.ZERO);
            item.setPctbf2(BigDecimal.ZERO);
            item.setPctbfn(BigDecimal.ZERO);

            //Precio final con bonificacion incluida
            BigDecimal precioFinal = ir.getPrecio().add(ir.getPrecio().multiply(item.getPctbfn()).divide(new BigDecimal(100)));

            item.setTotlin(precioFinal);

            item.setMonedaListaPrecio(m.getCoeficienteDeuda());
            item.setDeposito(m.getDeposito());
            item.setSector(m.getSector());
            item.setSucursal(m.getSucursal());
            item.setCliente(m.getCliente());
            item.setFchent(new Date());
            item.setFchhas(new Date());
            item.setUnimed(ir.getProducto().getUnidadMedida().getUnidad());
            item.setUnifac(ir.getProducto().getUnidadMedida().getUnidad());

            item.setMovimiento(m);

            m.getItemsProducto().add(item);
            movimientoFacturacionRN.calcularImportesDocumento(m);

        } catch (Exception e){
            m.getItemsProducto().remove(item);
            Logger.getLogger(getClass().getName()).log(Level.SEVERE, "agregoProductoPedido", e);            
            JsfUtil.addWarningMessage("No es posible generar pedido, disculpe las molestias");
        }
    }
        
    public void imprimirLista(){

    }
    
    //-----------------------------------
    
    public Pool getPool() {
        return pool;
    }

    public void setPool(Pool pool) {
        this.pool = pool;
    }

    public List<Pool> getLista() {
        return lista;
    }

    public void setLista(List<Pool> lista) {
        this.lista = lista;
    }
    

    public UsuarioSessionBean getUsuarioSession() {
        return usuarioSession;
    }

    public void setUsuarioSession(UsuarioSessionBean usuarioSession) {
        this.usuarioSession = usuarioSession;
    }

    public PoolAplicacionBean getPoolAplicacionBean() {
        return poolAplicacionBean;
    }

    public void setPoolAplicacionBean(PoolAplicacionBean poolAplicacionBean) {
        this.poolAplicacionBean = poolAplicacionBean;
    }

    public boolean isNuevo() {
        return nuevo;
    }

    public void setNuevo(boolean nuevo) {
        this.nuevo = nuevo;
    }

    public CondicionesPagoPool getItemCondicionPago() {
        return itemCondicionPago;
    }

    public void setItemCondicionPago(CondicionesPagoPool itemCondicionPago) {
        this.itemCondicionPago = itemCondicionPago;
    }

    public ItemProductoPool getItemProducto() {
        return itemProducto;
    }

    public void setItemProducto(ItemProductoPool itemProducto) {
        this.itemProducto = itemProducto;
    }

    public BuscadorProductoBean getBuscadorProductoBean() {
        return buscadorProductoBean;
    }

    public void setBuscadorProductoBean(BuscadorProductoBean buscadorProductoBean) {
        this.buscadorProductoBean = buscadorProductoBean;
    }

    public List<CondicionDePago> getListaCondicionesDePago() {
        return listaCondicionesDePago;
    }

    public void setListaCondicionesDePago(List<CondicionDePago> listaCondicionesDePago) {
        this.listaCondicionesDePago = listaCondicionesDePago;
    }

    public List<PoolTipo> getTipos() {
        return tipos;
    }

    public void setTipos(List<PoolTipo> tipos) {
        this.tipos = tipos;
    }

    public BasesCondicionesAdicionales getItemBasesCondicionesAdicionales() {
        return itemBasesCondicionesAdicionales;
    }

    public void setItemBasesCondicionesAdicionales(BasesCondicionesAdicionales itemBasesCondicionesAdicionales) {
        this.itemBasesCondicionesAdicionales = itemBasesCondicionesAdicionales;
    }

    public CondicionDePagoRN getCondicionDePagoRN() {
        return condicionDePagoRN;
    }

    public void setCondicionDePagoRN(CondicionDePagoRN condicionDePagoRN) {
        this.condicionDePagoRN = condicionDePagoRN;
    }

    public MonedaRN getMonedaRN() {
        return monedaRN;
    }

    public void setMonedaRN(MonedaRN monedaRN) {
        this.monedaRN = monedaRN;
    }

    public MovimientoFacturacionRN getMovimientoFacturacionRN() {
        return movimientoFacturacionRN;
    }

    public void setMovimientoFacturacionRN(MovimientoFacturacionRN movimientoFacturacionRN) {
        this.movimientoFacturacionRN = movimientoFacturacionRN;
    }

    public Parametro getP() {
        return p;
    }

    public void setP(Parametro p) {
        this.p = p;
    }

    public ParametrosRN getParametroRN() {
        return parametroRN;
    }

    public void setParametroRN(ParametrosRN parametroRN) {
        this.parametroRN = parametroRN;
    }

    public PoolRN getPoolRN() {
        return poolRN;
    }

    public void setPoolRN(PoolRN poolRN) {
        this.poolRN = poolRN;
    }

    public PoolTipoRN getPoolTipoRN() {
        return poolTipoRN;
    }

    public void setPoolTipoRN(PoolTipoRN poolTipoRN) {
        this.poolTipoRN = poolTipoRN;
    }

    public void asignarCodigoAceso(){
        
        //Asignamos códigos de acceso aleatorio        
        String codigoA = pool.getNroPool() + JsfUtil.getCadenaAlfanumAleatoria(30);
        pool.setCodigoAcceso(codigoA);
    }
    
}
